home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: Taifun / Taifun 094 (1989-05-15)(Ossowski, Stefan)(DE)(PD).zip / Taifun 094 (1989-05-15)(Ossowski, Stefan)(DE)(PD).adf / Quickmenu / SOURCE / QuickMenu1.0.c < prev    next >
C/C++ Source or Header  |  1989-01-27  |  14KB  |  615 lines
  1. /*****************************************************************************\
  2.  
  3.        QuickMenu               Geschrieben von Sauer Franz
  4.  
  5.   Arbeitszeiten:   10-06-88   2   Std.
  6.                    11-06-88   3   Std.
  7.                    21-06-88   4.5 Std.
  8.                    22-06-88   4   Std.
  9.                    23-06-88   5   Std.
  10.                    24-06-88   4   Std.
  11.                    25-06-88   8   Std.
  12.                    26-06-88   8   Std.
  13.  
  14.  
  15. \*****************************************************************************/
  16.  
  17. #include <exec/types.h>
  18. #include <exec/memory.h>
  19. #include <exec/tasks.h>
  20. #include <devices/timer.h>
  21. #include <libraries/dos.h>
  22. #include <intuition/intuitionbase.h>
  23. #include <libraries/dosextens.h>
  24. #include <stdio.h>
  25. #include <menu.h>
  26.  
  27.  
  28. /*****************************************************************************\
  29.  
  30.                     W I C H T I G E    K O N S T A N T E N
  31.  
  32. \*****************************************************************************/
  33.  
  34.  
  35.  
  36. #define INTUITION 0x00000001  /* Scließflags fÜr verschiedene Resourcen */
  37. #define GRAPHICS  0x00000002
  38. #define SCREEN    0x00000004
  39. #define WINDOW    0x00000008
  40. #define COLORMAP  0x00000010
  41. #define MENU      0x00000020
  42. #define DISK      0x00000040
  43.  
  44. #define INTUITION_REV   1
  45. #define WIN_BREITE      420      /* Breite des Uhren Fenster            */
  46. #define WAIT_TIME       2500
  47.  
  48. #define MAXMENUS    6            /* Maximale Anzahl der Hauptmenupunkte */
  49. #define MAXITEMS    10           /* Maximale Anzahl der Menupunkte      */
  50. #define MAXSUBS     5            /* Maximale Anzahl der Untermenupunkte */
  51. #define MAXFILES    300          /* Maximale Anzahl alle Menupunkte     */
  52. #define MENUTEXTL   20           /* Maximale Laenge des Menutextes      */
  53. #define COMMANDL    60           /* Maximale Laenge eines Befehls       */
  54. #define MENUABSTAND 10           /* Freiraum in Pixel zwischen den Menus */
  55.  
  56. void   *OpenLibrary();
  57. ULONG  AvailMem();
  58.  
  59. struct Window          *OpenWindow();
  60. struct IntuiMessage    *GetMsg();
  61. struct Window          *BuildSysRequest();
  62. struct Gadget          *GetReqGad();
  63. struct FileHandle      *fh, *fp, *Open(), *Output();
  64. struct IntuitionBase   *IntuitionBase;
  65. struct GfxBase         *GfxBase;
  66. struct IntuiMessage    *message;
  67. struct RastPort        *rp;
  68. struct Window          *w;
  69. struct timerequest     Time_Req;
  70. struct MsgPort         *Timer_Port = NULL, *CreatePort();
  71. struct DateStamp       jetzt;
  72. struct Task            *FindTask();
  73.  
  74. struct Menu       menu[MAXMENUS+1];
  75. struct MenuItem   mitem[MAXFILES];
  76. struct IntuiText  mtext[MAXFILES];
  77.  
  78. char Datum_Buffer[40];
  79.  
  80. struct IntuiText  Datum_Text = { 1, 0,JAM2,0,0,(struct TextAttr *) NULL,
  81.                                 Datum_Buffer,(struct IntuiText *) NULL  };
  82.  
  83.  
  84. /*****************************************************************************\
  85.  
  86.                         W I N D O W     S T R U K T U R
  87.  
  88. \*****************************************************************************/
  89.  
  90. struct NewWindow nw = {
  91.   (590-WIN_BREITE), 0,   /*  Start position                               */
  92.   WIN_BREITE, 10,        /*  Breite, Höhe,                                */
  93.   -1, -1,                /*  detail, block pens                           */
  94.   CLOSEWINDOW            /*  IDCMP Flags                                  */
  95. | REFRESHWINDOW
  96. | MOUSEBUTTONS
  97. | MENUPICK,
  98.                          /*  Flags                                        */
  99.   WINDOWDEPTH
  100. | WINDOWDRAG
  101. | WINDOWCLOSE
  102. | SMART_REFRESH
  103. | NOCAREREFRESH,
  104.  
  105.   NULL,                  /* Keine Gadgets                                 */
  106.   NULL,                  /* Keine Haken                                   */
  107.   "",
  108.   NULL,                  /* Screenzeiger wird später gesetzt              */
  109.   NULL,                  /* Keine SuperBitmap Zeiger                      */
  110.   0, 0, 0, 0,
  111.   WBENCHSCREEN,          /* Benutzt den Workbench Screen                  */
  112.   };
  113.  
  114.  
  115. int  itemanzahl[MAXMENUS+1];
  116. int  subanzahl[MAXMENUS+1][MAXITEMS+1];
  117. int  z1[MAXITEMS+1];
  118. int  subpos[MAXITEMS+1];
  119. int  maxitemlen[MAXMENUS+1];
  120. int  aktmenu,menuanz;
  121.  
  122. short stunden,minuten;
  123. int   chip_frei,fast_frei;
  124. long  mask = 0;
  125. ULONG DosBase;
  126.  
  127. char excommand[MAXMENUS+1][MAXITEMS+1][MAXSUBS+1][COMMANDL+1];
  128. char menutext[MAXMENUS+1][MAXITEMS+1][MAXSUBS+1][MENUTEXTL+1];
  129. char *filebuffer;
  130. int  *menunr;
  131.  
  132. /*****************************************************************************\
  133.  
  134.                          M A I N     P R O G R A M M
  135.  
  136. \*****************************************************************************/
  137.  
  138.  
  139. main()
  140.  
  141. {
  142.  
  143. ULONG  class;
  144. USHORT code;
  145. int    r,i;
  146. BOOL   cont = 1;
  147. USHORT menunum;
  148. USHORT itemnum;
  149. USHORT subnum;
  150. USHORT erlaubt=1;
  151.  
  152. if(!(GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",0)))
  153.   {
  154.   printf("Finde leider die 'Graphics Library' nicht !!!\n");
  155.   Schliessen();
  156.   exit(30);
  157.   }
  158.  
  159. mask |= GRAPHICS;
  160.  
  161. if(!(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",0)))
  162.   {
  163.   printf("Finde leider keine 'Intuition' vor !!\n");
  164.   Schliessen();
  165.   exit(30);
  166.   }
  167.  
  168. mask |= INTUITION;
  169.  
  170. if (!(w = (struct Window *)OpenWindow(&nw) ))
  171.    {
  172.    printf("Kann mein 'Window' nicht öffnen\n");
  173.    Schliessen();
  174.    exit(10);
  175.    }
  176.  
  177. mask |= WINDOW;
  178.  
  179. if (!(Timer_Port = CreatePort("Timer Port",0)))
  180.    {
  181.    printf("Kann das 'TIMER PORT' nicht öffnen\n");
  182.    Schliessen();
  183.    exit(30);
  184.    }
  185.  
  186. if (OpenDevice(TIMERNAME,UNIT_VBLANK,(char *)&Time_Req,0)!=NULL)
  187.    {
  188.    printf("Kann das 'TIMER DEVICE' nicht öffnen\n");
  189.    Schliessen();
  190.    exit(30);
  191.    }
  192.  
  193. if (!(DosBase=OpenLibrary("dos.library",0)))
  194.    {
  195.    printf("Kann das 'DOS' nicht öffnen !!\n");
  196.    Schliessen();
  197.    exit(30);
  198.    }
  199.  
  200. if (!(fp=Open("s:QuickMenu.Config",MODE_OLDFILE)))
  201.    {
  202.    printf ("Konnte 's:QuickMenu.Config' nicht öffnen !\n");
  203.    Schliessen();
  204.    exit(10);
  205.    }
  206.  
  207. mask |= DISK;
  208.  
  209. rp = w->RPort;
  210. Time_Req.tr_node.io_Message.mn_ReplyPort = Timer_Port;
  211. Time_Req.tr_node.io_Command              = TR_ADDREQUEST;
  212. Time_Req.tr_node.io_Flags                = 0;
  213. Time_Req.tr_node.io_Error                = 0;
  214.  
  215. SetTaskPri(FindTask((char *)0),0);
  216. Variablenloeschen();
  217. Liesconfig ();
  218. Menuinit ();
  219.  
  220. /*****************************************************************************\
  221.  
  222.                         E R E I G N I S A B F R A G E
  223.  
  224. \*****************************************************************************/
  225.  
  226.  
  227. for ( ; ; )
  228.     {
  229.     if ((message=(struct IntuiMessage *)GetMsg(w->UserPort))==0L ) /* && (message=GetMsg(Timer_Port))==0L ) */
  230.        {
  231.        if (erlaubt==1)
  232.           Uhrsetzen ();
  233.        Wait(1 << w->UserPort->mp_SigBit | 1 << Timer_Port->mp_SigBit);
  234.        erlaubt=1;
  235.        continue;
  236.        }
  237.     if ( message->Class )
  238.        {
  239.        class = message->Class;
  240.        code =  message->Code;
  241.        ReplyMsg(message);
  242.        erlaubt =0;
  243.        switch (class)
  244.               {
  245.               case CLOSEWINDOW : Schliessen ();
  246.                                  exit(0);
  247.                                  break;
  248.  
  249.               case MENUPICK    : if (MENUNUM(code) != MENUNULL)
  250.                                     domenu(MENUNUM(code),ITEMNUM(code),SUBNUM(code));
  251.                                     break;
  252.  
  253.              case MOUSEBUTTONS : Delay(20);
  254.                                  break;
  255.  
  256.               }      /* Case */
  257.        Delay(40);
  258.        }
  259.     }                /* for           */
  260. }                    /* Ende von Main */
  261.  
  262.  
  263.  
  264.  
  265.  
  266. /*****************************************************************************\
  267.  
  268.                         P R O G R A M M R O U T I N E N
  269.  
  270. \*****************************************************************************/
  271.  
  272. Uhrsetzen ()
  273.  
  274. {
  275.  
  276. DateStamp(&jetzt);
  277. chip_frei = AvailMem(MEMF_CHIP);
  278. fast_frei = AvailMem(MEMF_FAST);
  279. stunden   = jetzt.ds_Minute/60;
  280. minuten   = jetzt.ds_Minute%60;
  281. sprintf(Datum_Buffer, " Chip:%6d  Fast:%7d  Time:%2d:%02d:%02d ",chip_frei, fast_frei,stunden,minuten,jetzt.ds_Tick/TICKS_PER_SECOND);
  282. PrintIText(rp,&Datum_Text,28,1);
  283. Time_Req.tr_time.tv_secs  = 1;
  284. Time_Req.tr_time.tv_micro = WAIT_TIME;
  285. SendIO ((char *)&Time_Req.tr_node);
  286.  
  287. }
  288.  
  289.  
  290.  
  291.  
  292.  
  293.  
  294.  
  295. domenu (menu,item,subitem)
  296.  
  297. int menu,item,subitem;
  298.  
  299. {
  300.  
  301. if ( menu > menuanz )
  302.    return;
  303.  
  304. menu=menuanz-menu;
  305. if ( item > itemanzahl[menu] ) item=0; else item++;
  306. if ( subitem > subanzahl[menu][item] ) subitem=0; else subitem++;
  307.  
  308. Execute (excommand[menu][item][subitem],0,0);
  309.  
  310. }
  311.  
  312.  
  313.  
  314.  
  315.  
  316.  
  317. Schliessen ()
  318.  
  319. {
  320.    AbortIO((char *) &Time_Req . tr_node);
  321.    if (Time_Req . tr_node . io_Message . mn_ReplyPort) CloseDevice(&Time_Req);
  322.    if (Timer_Port)       DeletePort(Timer_Port);
  323.    if ( fp!=0 )          Close(fp);
  324.    if (mask & MENU)      ClearMenuStrip(w);
  325.    if (mask & WINDOW)    CloseWindow(w);
  326.    if (mask & GRAPHICS)  CloseLibrary(GfxBase);
  327.    if (mask & INTUITION) CloseLibrary(IntuitionBase);
  328. }
  329.  
  330.  
  331. Liesconfig ()
  332.  
  333. {
  334.  
  335. int  r,r1;
  336. int  m[3];
  337. char befehl[200];
  338. int  filelaenge;
  339.  
  340. r=r1=0;
  341.  
  342. Seek(fp,0L,OFFSET_END);
  343.  
  344. if (!(filelaenge=Seek (fp,0L,OFFSET_BEGINNING)))
  345.    {
  346.    printf ("'QuickMenu.Config' nicht in Ordnung !!!\n");
  347.    Schliessen ();
  348.    exit (20);
  349.    }
  350.  
  351. filebuffer = AllocMem (filelaenge+1,MEMF_FAST|MEMF_CLEAR);
  352.  
  353. if ( filebuffer==0 )
  354.    {
  355.    printf ("Nicht genug Speicherplatz !!!\n");
  356.    Schliessen ();
  357.    exit (20);
  358.    }
  359.  
  360.  
  361. Read (fp,filebuffer,filelaenge);
  362.  
  363. do    {
  364.       aktmenu++;         /*  Gesamtanzahl der aktuellen Menus */
  365.       r=0;
  366.       do    {
  367.             befehl[r++]=filebuffer[r1++];
  368.             }
  369.       while ( befehl[r-1]!='\n' );
  370.  
  371.       befehl[r-1]='\0';
  372.       if ( r==1 )
  373.          aktmenu--;
  374.       if ( aktmenu>MAXFILES-2 )
  375.          {
  376.          printf ("Achtung !!! Zu viele MenÜs. ( Maximal %ld )\n",MAXFILES-2);
  377.          Schliessen ();
  378.          exit (20);
  379.          }
  380.       Machbefehl(befehl);
  381.       }
  382. while ( r1<= filelaenge-1 );
  383.  
  384. FreeMem (filebuffer,filelaenge+1);
  385.  
  386. Close (fp);
  387. fp=0;
  388.  
  389. }
  390.  
  391.  
  392.  
  393.  
  394. Machbefehl (befehl)
  395.  
  396.  
  397. char *befehl;
  398.  
  399. {
  400.  
  401. int  m[3],u,u1,r2;
  402. char mt[2],text[250],command[250];
  403. u1=0;
  404.  
  405. for ( u=0 ; u<3 ; u++ )
  406.     {
  407.     mt[0]=befehl[u1++];
  408.     mt[1]=befehl[u1++];
  409.     mt[2]='\0';
  410.     m[u]= atoi(&mt);
  411.     u1++;
  412.     }
  413. u1++;r2=0;
  414.  
  415. do    {
  416.       text[r2++]=befehl[u1++];
  417.       }
  418. while ( befehl[u1-1]!='"' );
  419.       text[r2-1]='\0';
  420.  
  421. u1+=2;r2=0;
  422.  
  423. do    {
  424.       command[r2++]=befehl[u1++];
  425.       }
  426. while ( befehl[u1-1]!='"' );
  427.       command[r2-1]='\0';
  428.  
  429. text[MENUTEXTL-1]='\0';
  430. command[COMMANDL-1]='\0';
  431.  
  432. Menulesen (m[0],m[1],m[2],text,command);
  433.  
  434. }
  435.  
  436.  
  437.  
  438. Menulesen (m,mi,ms,text,command)
  439.  
  440. int  m,mi,ms;
  441.  
  442. char *text;
  443. char *command;
  444.  
  445.  
  446. {
  447.  
  448. int r;
  449.  
  450. if ( m>MAXMENUS )
  451.    {
  452.    printf ("Achtung !!!  Zu viel MenÜleisten. ( Max %ld )\n",MAXMENUS);
  453.    Schliessen();
  454.    exit (20);
  455.    }
  456.  
  457. if ( mi>MAXITEMS )
  458.    {
  459.    printf ("Achtung !!!  Zu viel MenÜpunkte. ( Max %ld )\n",MAXITEMS);
  460.    Schliessen();
  461.    exit (20);
  462.    }
  463.  
  464. if ( ms>MAXSUBS )
  465.    {
  466.    printf ("Achtung !!!  Zu viel UntermenÜpunkte. ( Max %ld )\n",MAXSUBS);
  467.    Schliessen();
  468.    exit (20);
  469.    }
  470.  
  471. r=0;
  472. while ( text[r++]!='\0' )
  473.       menutext[m][mi][ms][r-1]=text[r-1];
  474.  
  475. if (menuanz<m) menuanz=m;
  476. if (itemanzahl[m]<mi) itemanzahl[m]=mi;
  477. if (subanzahl[m][mi]<ms) subanzahl[m][mi]=ms;
  478.  
  479. strcpy (excommand[m][mi][ms],"Run ");
  480. r=0;
  481. while ( command[r++]!='\0' )
  482.       excommand[m][mi][ms][r+3]=command[r-1];
  483.  
  484. }
  485.  
  486.  
  487.  
  488.  
  489. Variablenloeschen()
  490.  
  491. {
  492.  
  493. int r0,r1;
  494.  
  495. menuanz=0;
  496.  
  497. for ( r0=0 ; r0<= MAXMENUS ; r0++ )
  498.     {
  499.     itemanzahl[r0]=0;
  500.     for ( r1=0 ; r1<= MAXITEMS ; r1++ )
  501.         {
  502.         subanzahl[r0][r1]=0;
  503.         z1[r1]=0;
  504.         }
  505.     }
  506.  
  507. }
  508.  
  509.  
  510.  
  511. Menuinit ()
  512.  
  513. {
  514.  
  515. int    m,mi,ms;
  516. int    z,z2;
  517. int    mtoffset=0;
  518.  
  519. z=0;
  520.  
  521. for ( m=1 ; m<= menuanz ; m++ )
  522.     mtoffset=mtoffset+(strlen(menutext[m][0][0])*8)+MENUABSTAND;
  523.  
  524. if ( mtoffset>639 )
  525.    {
  526.    printf ("Die HauptmenÜpunkte wÜrden eine Screenbreite von %ld Punkten erfordern.\n",mtoffset);
  527.    Schliessen();
  528.    exit(30);
  529.    }
  530.  
  531.  
  532. mtoffset=0;
  533.  
  534. for ( m=1 ; m<= menuanz ; m++ )
  535.     {
  536.     cr_MenuTitle  (&mitem[z],menutext[m][0][0],&menu[m]);
  537.     z++;
  538.     if (itemanzahl[m]>0)
  539.        {
  540.        for ( mi=1 ; mi<= itemanzahl[m] ; mi++ )
  541.            {
  542.            if ( mi < 5 )
  543.               subpos[mi]=0;
  544.            else
  545.               subpos[mi]=1;
  546.            if ( mi < itemanzahl[m] )
  547.               {
  548.               cr_MenuText   (&mitem[z],menutext[m][mi][0],0,&mitem[z-1],&mtext[z-1]);
  549.               z1[mi]=z-1;
  550.               z++;
  551.               }
  552.            else
  553.               {
  554.               cr_MenuText   (NULL,menutext[m][mi][0],0,&mitem[z-1],&mtext[z-1]);
  555.               z1[mi]=z-1;
  556.               z++;
  557.               }
  558.            if ( z>MAXFILES-2 )
  559.               {
  560.               printf ("Achtung !!! Zu viele MenÜs. ( Maximal %ld )\n",MAXFILES-2);
  561.               Schliessen ();
  562.               exit (20);
  563.               }
  564.            }
  565.        }
  566.  
  567.     if ( m==1 )
  568.        cr_Menu (w,NULL,&menu[m],mtoffset,0,1,0);
  569.        else
  570.        cr_Menu (w,&menu[m-1],&menu[m],mtoffset,-20,1,0);
  571.  
  572.     mtoffset=mtoffset+(strlen(menutext[m][0][0])*8)+MENUABSTAND;
  573.  
  574.     if (itemanzahl[m]>1)
  575.        {
  576.        for ( mi=1 ; mi<= itemanzahl[m] ; mi++ )
  577.            {
  578.            if (subanzahl[m][mi]>1)
  579.               {
  580.               if (subanzahl[m][mi]>1)
  581.                  {
  582.                  z2=z; /* z2=z-1  */
  583.                  for ( ms=0 ; ms<=subanzahl[m][mi] ; ms++ )
  584.                      {
  585.  
  586.                      if ( ms < subanzahl[m][mi] )
  587.                         {
  588.                         cr_MenuText(&mitem[z],menutext[m][mi][ms],0,&mitem[z-1],&mtext[z-1]);
  589.                         z++;
  590.                         }
  591.                      else
  592.                         {
  593.                         cr_MenuText   (NULL,menutext[m][mi][ms],0,&mitem[z-1],&mtext[z-1]);
  594.                         cr_SubMenu    (&mitem[z1[mi]],&mitem[z2],50,subpos[mi],0,0);
  595.                         z++;
  596.                         }
  597.                      if ( z>MAXFILES-2 )
  598.                         {
  599.                         printf ("Achtung !!! Zu viele MenÜs. ( Maximal %ld )\n",MAXFILES-2);
  600.                         Schliessen ();
  601.                         exit (20);
  602.                         }
  603.                      }
  604.                  }
  605.               }
  606.            }
  607.        }
  608.     }
  609.  
  610. mask |= MENU;
  611.  
  612. }
  613.  
  614.  
  615.